/**
 * 用户端分类和标签API
 * 用于文章发布时选择分类和标签
 */

import { http } from "@/utils/http";

// ==================== 类型定义 ====================

/** API响应基础结构 */
export interface ApiResponse<T = any> {
  code: number;
  message: string;
  data: T;
  timestamp: number;
}

/** 简单分类信息 */
export interface SimpleCategoryInfo {
  id: number;
  name: string;
  description: string;
  icon?: string;
}

/** 简单标签信息 */
export interface SimpleTagInfo {
  id: number;
  name: string;
  color: string;
}

// ==================== API接口函数 ====================

/**
 * 获取启用的分类列表
 * 用于文章发布时选择分类
 */
export const getEnabledCategoriesApi = () => {
  return http.request<ApiResponse<SimpleCategoryInfo[]>>(
    "get",
    "/api/categories/enabled"
  );
};

/**
 * 获取启用的标签列表
 * 用于文章发布时选择标签
 */
export const getEnabledTagsApi = () => {
  return http.request<ApiResponse<SimpleTagInfo[]>>("get", "/api/tags/enabled");
};

/**
 * 搜索标签（自动完成）
 * 用于标签输入时的自动完成功能
 * @param keyword 搜索关键词
 * @param limit 返回数量限制，默认10个
 */
export const searchTagsApi = (keyword: string, limit: number = 10) => {
  return http.request<ApiResponse<SimpleTagInfo[]>>("get", "/api/tags/search", {
    params: { keyword, limit }
  });
};

/**
 * 获取热门标签
 * 用于标签选择时的推荐
 * @param limit 返回数量限制，默认20个
 */
export const getHotTagsApi = (limit: number = 20) => {
  return http.request<ApiResponse<SimpleTagInfo[]>>("get", "/api/tags/hot", {
    params: { limit }
  });
};

// ==================== 工具函数 ====================

/**
 * 分类和标签工具类
 */
export class CategoryTagUtils {
  /**
   * 格式化分类选项
   * @param categories 分类列表
   * @returns 格式化后的选项
   */
  static formatCategoryOptions(categories: SimpleCategoryInfo[]) {
    return categories.map(category => ({
      label: category.name,
      value: category.id,
      description: category.description,
      icon: category.icon
    }));
  }

  /**
   * 格式化标签选项
   * @param tags 标签列表
   * @returns 格式化后的选项
   */
  static formatTagOptions(tags: SimpleTagInfo[]) {
    return tags.map(tag => ({
      label: tag.name,
      value: tag.id,
      color: tag.color
    }));
  }

  /**
   * 根据ID查找分类
   * @param categories 分类列表
   * @param categoryId 分类ID
   * @returns 找到的分类或null
   */
  static findCategoryById(
    categories: SimpleCategoryInfo[],
    categoryId: number
  ): SimpleCategoryInfo | null {
    return categories.find(category => category.id === categoryId) || null;
  }

  /**
   * 根据ID列表查找标签
   * @param tags 标签列表
   * @param tagIds 标签ID列表
   * @returns 找到的标签列表
   */
  static findTagsByIds(
    tags: SimpleTagInfo[],
    tagIds: number[]
  ): SimpleTagInfo[] {
    return tags.filter(tag => tagIds.includes(tag.id));
  }

  /**
   * 验证分类ID
   * @param categoryId 分类ID
   * @returns 是否有效
   */
  static validateCategoryId(categoryId: any): boolean {
    return typeof categoryId === "number" && categoryId > 0;
  }

  /**
   * 验证标签ID列表
   * @param tagIds 标签ID列表
   * @returns 是否有效
   */
  static validateTagIds(tagIds: any): boolean {
    if (!Array.isArray(tagIds)) return true; // 标签是可选的
    return tagIds.every(id => typeof id === "number" && id > 0);
  }

  /**
   * 生成标签颜色样式
   * @param color 颜色值
   * @returns CSS样式对象
   */
  static generateTagStyle(color: string) {
    return {
      backgroundColor: color + "20", // 20% 透明度背景
      borderColor: color,
      color: color
    };
  }

  /**
   * 处理标签搜索结果
   * @param searchResult 搜索结果
   * @param existingTags 已选择的标签
   * @returns 过滤后的搜索结果
   */
  static filterSearchResults(
    searchResult: SimpleTagInfo[],
    existingTags: SimpleTagInfo[]
  ): SimpleTagInfo[] {
    const existingIds = existingTags.map(tag => tag.id);
    return searchResult.filter(tag => !existingIds.includes(tag.id));
  }

  /**
   * 生成标签显示文本
   * @param tag 标签信息
   * @returns 显示文本
   */
  static generateTagDisplayText(tag: SimpleTagInfo): string {
    return `#${tag.name}`;
  }

  /**
   * 解析标签输入文本
   * @param input 输入文本
   * @returns 解析后的标签名称列表
   */
  static parseTagInput(input: string): string[] {
    return input
      .split(/[,，\s]+/) // 支持逗号、中文逗号、空格分隔
      .map(tag => tag.trim().replace(/^#/, "")) // 移除开头的#号
      .filter(tag => tag.length > 0);
  }

  /**
   * 验证标签名称
   * @param tagName 标签名称
   * @returns 验证结果
   */
  static validateTagName(tagName: string): {
    valid: boolean;
    message?: string;
  } {
    if (!tagName || tagName.trim().length === 0) {
      return { valid: false, message: "标签名称不能为空" };
    }

    if (tagName.length > 20) {
      return { valid: false, message: "标签名称不能超过20个字符" };
    }

    if (!/^[\u4e00-\u9fa5a-zA-Z0-9_-]+$/.test(tagName)) {
      return {
        valid: false,
        message: "标签名称只能包含中文、英文、数字、下划线和连字符"
      };
    }

    return { valid: true };
  }

  /**
   * 生成随机标签颜色
   * @returns 随机颜色值
   */
  static generateRandomTagColor(): string {
    const colors = [
      "#ff6b6b",
      "#4ecdc4",
      "#45b7d1",
      "#96ceb4",
      "#feca57",
      "#ff9ff3",
      "#54a0ff",
      "#5f27cd",
      "#00d2d3",
      "#ff9f43",
      "#10ac84",
      "#ee5a24",
      "#0abde3",
      "#3867d6",
      "#8854d0"
    ];
    return colors[Math.floor(Math.random() * colors.length)];
  }
}
